// #include "viml/compiler.h"
// #include "viml/vm.h"
// #include "viml/value.h"
// #include <gtest/gtest.h>
// #include <iostream>
// #include <chrono>
// #include <thread>

// namespace viml {

// class DebugLoopDelayTest : public ::testing::Test {
// protected:
//     void SetUp() override {
//         // Setup code if needed
//     }

//     void TearDown() override {
//         // Cleanup code if needed
//     }
// };

// // 测试在调试模式下for循环延迟
// TEST_F(DebugLoopDelayTest, ForLoopDelay) {
//     Compiler compiler;
//     VM vm;
    
//     // 启用调试模式和循环延迟
//     vm.set_debug_mode(true);
//     vm.set_loop_delay_enabled(true);
//     vm.set_debug_loop_delay(50); // 50ms延迟
    
//     // 测试代码: for i in [1,2,3] \n echo i \n endfor
//     std::string source = R"(
//         for i in [1,2,3]
//             echo i
//         endfor
//     )";
    
//     try {
//         auto bytecode = compiler.compile(source);
        
//         // 记录执行时间
//         auto start = std::chrono::high_resolution_clock::now();
//         Value result = vm.execute(bytecode);
//         auto end = std::chrono::high_resolution_clock::now();
        
//         // 验证执行成功
//         EXPECT_TRUE(true);
        
//         // 验证执行时间符合预期(至少150ms延迟，3次迭代)
//         auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
//         EXPECT_GE(duration.count(), 150);
//     } catch (const std::exception& e) {
//         FAIL() << "Compilation or execution failed: " << e.what();
//     }
// }

// // 测试在调试模式下while循环延迟
// TEST_F(DebugLoopDelayTest, WhileLoopDelay) {
//     Compiler compiler;
//     VM vm;
    
//     // 启用调试模式和循环延迟
//     vm.set_debug_mode(true);
//     vm.set_loop_delay_enabled(true);
//     vm.set_debug_loop_delay(30); // 30ms延迟
//     vm.set_loop_timeout(1000); // 设置更长的超时时间
    
//     // 测试代码: let i = 0 \n while i < 3 \n echo i \n let i = i + 1 \n endwhile
//     std::string source = R"(
//         let i = 0
//         while i < 3
//             echo i
//             let i = i + 1
//         endwhile
//     )";
    
//     try {
//         auto bytecode = compiler.compile(source);
        
//         // 记录执行时间
//         auto start = std::chrono::high_resolution_clock::now();
//         Value result = vm.execute(bytecode);
//         auto end = std::chrono::high_resolution_clock::now();
        
//         // 验证执行成功
//         EXPECT_TRUE(true);
        
//         // 验证执行时间符合预期(至少90ms延迟，3次迭代)
//         auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
//         EXPECT_GE(duration.count(), 90);
//     } catch (const std::exception& e) {
//         FAIL() << "Compilation or execution failed: " << e.what();
//     }
// }

// // 测试循环超时机制
// TEST_F(DebugLoopDelayTest, WhileLoopTimeout) {
//     Compiler compiler;
//     VM vm;
    
//     // 启用调试模式和超时
//     vm.set_debug_mode(true);
//     vm.set_loop_timeout(100); // 100ms超时
//     vm.set_loop_delay_enabled(false); // 不启用延迟以加快测试
    
//     // 测试代码: while true \n echo 'loop' \n endwhile (无限循环)
//     std::string source = R"(
//         let i = 0
//         while i < 1000000  # 很大的循环次数
//             let i = i + 1
//         endwhile
//     )";
    
//     try {
//         auto bytecode = compiler.compile(source);
//         Value result = vm.execute(bytecode);
//         FAIL() << "Expected exception but none was thrown";
//     } catch (const std::exception& e) {
//         // 验证抛出异常包含超时信息
//         std::string error_msg = e.what();
//         EXPECT_TRUE(error_msg.find("timeout") != std::string::npos);
//     }
// }

// // 测试无限循环检测
// TEST_F(DebugLoopDelayTest, InfiniteLoopDetection) {
//     Compiler compiler;
//     VM vm;
    
//     // 启用调试模式和无限循环检测
//     vm.set_debug_mode(true);
//     vm.enable_infinite_loop_detection(true);
//     vm.set_debug_loop_delay(1); // 设置很小的延迟以加快测试
//     vm.set_loop_timeout(1000); // 设置较长的超时时间
//     vm.set_loop_delay_enabled(true); // 启用延迟以触发检测
//     vm.set_max_loop_iterations(100); // 设置较小的迭代次数阈值
    
//     // 测试代码: let i = 0 \n while i < 1000 \n let i = i + 0 \n endwhile (无限循环)
//     std::string source = R"(
//         let i = 0
//         while i < 1000
//             let i = i + 0  # i不会改变，形成无限循环
//         endwhile
//     )";
    
//     try {
//         auto bytecode = compiler.compile(source);
//         Value result = vm.execute(bytecode);
//         FAIL() << "Expected exception but none was thrown";
//     } catch (const std::exception& e) {
//         // 验证抛出异常包含无限循环检测信息
//         std::string error_msg = e.what();
//         EXPECT_TRUE(error_msg.find("infinite") != std::string::npos || 
//                    error_msg.find("loop") != std::string::npos);
//     }
// }

// // 测试正常模式下不启用延迟
// TEST_F(DebugLoopDelayTest, NormalModeNoDelay) {
//     Compiler compiler;
//     VM vm;
    
//     // 确保关闭调试模式
//     vm.set_debug_mode(false);
//     vm.set_loop_delay_enabled(true);
//     vm.set_debug_loop_delay(50); // 50ms延迟
    
//     // 测试代码: for i in [1,2,3] \n echo i \n endfor
//     std::string source = R"(
//         for i in [1,2,3]
//             echo i
//         endfor
//     )";
    
//     try {
//         auto bytecode = compiler.compile(source);
        
//         // 记录执行时间
//         auto start = std::chrono::high_resolution_clock::now();
//         Value result = vm.execute(bytecode);
//         auto end = std::chrono::high_resolution_clock::now();
        
//         // 验证执行成功
//         EXPECT_TRUE(true);
        
//         // 验证执行时间很短(不应有延迟)
//         auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
//         EXPECT_LT(duration.count(), 50);
//     } catch (const std::exception& e) {
//         FAIL() << "Compilation or execution failed: " << e.what();
//     }
// }

// } // namespace viml